// utils/coze.js - Coze API 工具（临时使用直接调用）

const COZE_API_KEY = 'cztei_qc9edB4DWNu0Sqa0fFAl0vV7zjvITN9DfSDXgEIckPGN7W3tAvu4b6PjqEBb6PHtJ';
const COZE_BOT_ID = '7555475919377367075';
const COZE_API_URL = 'https://api.coze.cn/open_api/v2/chat';

/**
 * 调用 Coze 智能体进行对话（直接API调用）
 * @param {string} message - 用户消息
 * @param {string} conversationId - 会话ID（可选）
 * @returns {Promise} 返回 AI 响应
 */
function chatWithCoze(message, conversationId = null) {
  // 直接使用API调用（更可靠）
  const apiEndpoints = [
    'https://api.coze.cn/open_api/v2/chat'
    // 注意：v1 端点已废弃，移除
  ];
  
  return tryApiEndpoints(apiEndpoints, message, conversationId);
}

/**
 * 调用云函数代理 Coze API
 */
function callCloudFunction(message, conversationId) {
  return new Promise((resolve, reject) => {
    console.log('☁️ 调用云函数代理 Coze API...');
    console.log('📝 消息:', message.substring(0, 50));
    console.log('💬 会话ID:', conversationId);
    
    wx.cloud.callFunction({
      name: 'coze-proxy',
      data: {
        message: message,
        conversationId: conversationId || 'chat-' + Date.now()
      },
      success: (res) => {
        console.log('✅ 云函数调用成功');
        console.log('📦 云函数响应:', res);
        console.log('📊 result.success:', res.result?.success);
        console.log('📋 result.data:', res.result?.data);
        
        if (res.result && res.result.success && res.result.data) {
          // 解析响应数据（与直接API调用相同的逻辑）
          const data = res.result.data;
          
          // 检查是否有错误码
          if (data.code && data.code !== 0) {
            const errorMsg = data.msg || data.message || res.result.error || 'API返回错误';
            console.error('❌ 云函数返回错误码:', data.code);
            console.error('❌ 错误信息:', errorMsg);
            reject(new Error(errorMsg));
            return;
          }
          
          let contentToResolve = null;
          
          // 格式1：v2格式 - messages数组
          if (data.messages && Array.isArray(data.messages) && data.messages.length > 0) {
            const lastMessage = data.messages[data.messages.length - 1];
            contentToResolve = lastMessage.content || lastMessage.text || lastMessage.message || '';
            console.log('使用 v2 messages 格式，内容:', contentToResolve);
          }
          // 格式2：直接content字段
          else if (data.content) {
            contentToResolve = data.content;
            console.log('使用 content 字段格式，内容:', contentToResolve);
          }
          // 格式3：response字段
          else if (data.response) {
            contentToResolve = data.response;
            console.log('使用 response 字段格式，内容:', contentToResolve);
          }
          // 格式4：data字段
          else if (data.data) {
            contentToResolve = data.data;
            console.log('使用 data.data 格式，内容:', contentToResolve);
          }
          // 格式5：字符串直接返回
          else if (typeof data === 'string') {
            contentToResolve = data;
            console.log('响应为字符串格式，内容:', contentToResolve);
          }
          
          if (contentToResolve) {
            resolve({
              content: contentToResolve
            });
          } else {
            console.error('❌ 无法识别云函数响应格式');
            console.error('📦 完整响应数据:', JSON.stringify(data));
            console.error('🔍 响应数据的键:', Object.keys(data || {}));
            reject(new Error('AI 响应格式无法识别，返回: ' + JSON.stringify(data).substring(0, 200)));
          }
        } else {
          console.error('❌ 云函数返回失败');
          console.error('📦 完整响应:', res.result);
          reject(new Error('云函数调用失败: ' + JSON.stringify(res.result)));
        }
      },
      fail: (err) => {
        console.error('❌ 云函数调用失败');
        console.error('🔴 错误详情:', err);
        reject(new Error('云函数调用失败: ' + (err.errMsg || JSON.stringify(err))));
      }
    });
  });
}

/**
 * 尝试多个API端点
 */
function tryApiEndpoints(endpoints, message, conversationId, index = 0) {
  if (index >= endpoints.length) {
    throw new Error('所有API端点都失败了');
  }
  
  const currentEndpoint = endpoints[index];
  console.log(`尝试API端点 ${index + 1}/${endpoints.length}:`, currentEndpoint);
  
  return callCozeApi(currentEndpoint, message, conversationId)
    .catch(error => {
      console.warn(`API端点 ${currentEndpoint} 失败:`, error.message);
      if (index < endpoints.length - 1) {
        return tryApiEndpoints(endpoints, message, conversationId, index + 1);
      } else {
        throw error;
      }
    });
}

/**
 * 调用单个API端点
 */
function callCozeApi(apiUrl, message, conversationId) {
  return new Promise((resolve, reject) => {
    console.log('🚀 直接调用 Coze API...');
    console.log('📍 API URL:', apiUrl);
    console.log('🆔 Bot ID:', COZE_BOT_ID);
    console.log('🔑 API Key 长度:', COZE_API_KEY?.length || 0);
    console.log('🔑 API Key 前20字符:', COZE_API_KEY?.substring(0, 20) + '...');
    console.log('🔑 API Key 后20字符:', '...' + COZE_API_KEY?.substring(COZE_API_KEY.length - 20));
    console.log('📝 请求消息:', message.substring(0, 100));
    console.log('💬 会话ID:', conversationId);
    
    wx.request({
      url: apiUrl,
      method: 'POST',
      header: {
        'Authorization': `Bearer ${COZE_API_KEY}`,
        'Content-Type': 'application/json'
      },
      data: {
        conversation_id: conversationId || 'chat-' + Date.now(),
        bot_id: COZE_BOT_ID,
        user: 'miniprogram-user-' + Date.now(),
        query: message,
        stream: false
      },
      success: (res) => {
        console.log('✅ Coze API 响应成功');
        console.log('📊 Coze API 响应状态码:', res.statusCode);
        console.log('📦 Coze API 响应数据:', res.data);
        console.log('🔍 响应数据类型:', typeof res.data);
        console.log('📋 响应数据结构:', JSON.stringify(res.data).substring(0, 500));
        
        if (res.statusCode === 200) {
          // 首先检查是否有错误码（即使状态码是200）
          if (res.data && res.data.code && res.data.code !== 0) {
            const errorMsg = res.data.msg || res.data.message || 'API返回错误';
            console.error('❌ Coze API 返回错误码:', res.data.code);
            console.error('❌ 错误信息:', errorMsg);
            
            // 根据错误码提供更详细的错误信息
            let detailedError = errorMsg;
            if (res.data.code === 4101) {
              detailedError = 'API Key 无效，请检查配置。错误: ' + errorMsg;
            } else if (res.data.code === 4102) {
              detailedError = 'Bot ID 无效，请检查配置。错误: ' + errorMsg;
            }
            
            reject(new Error(detailedError));
            return;
          }
          
          // 详细的响应处理逻辑
          if (res.data) {
            // 检查多种可能的响应格式
            let contentToResolve = null;
            
            // 格式1：v2格式 - messages数组
            if (res.data.messages && Array.isArray(res.data.messages) && res.data.messages.length > 0) {
              const lastMessage = res.data.messages[res.data.messages.length - 1];
              contentToResolve = lastMessage.content || lastMessage.text || lastMessage.message || '';
              console.log('使用 v2 messages 格式，内容:', contentToResolve);
            }
            // 格式2：直接content字段
            else if (res.data.content) {
              contentToResolve = res.data.content;
              console.log('使用 content 字段格式，内容:', contentToResolve);
            }
            // 格式3：response字段
            else if (res.data.response) {
              contentToResolve = res.data.response;
              console.log('使用 response 字段格式，内容:', contentToResolve);
            }
            // 格式4：data字段
            else if (res.data.data) {
              contentToResolve = res.data.data;
              console.log('使用 data.data 格式，内容:', contentToResolve);
            }
            // 格式5：字符串直接返回
            else if (typeof res.data === 'string') {
              contentToResolve = res.data;
              console.log('响应为字符串格式，内容:', contentToResolve);
            }
            
            if (contentToResolve) {
              resolve({
                content: contentToResolve
              });
            } else {
              console.error('❌ 无法识别响应格式');
              console.error('📦 完整响应数据:', JSON.stringify(res.data));
              console.error('🔍 响应数据的键:', Object.keys(res.data || {}));
              console.error('📋 响应数据类型:', typeof res.data);
              reject(new Error('AI 响应格式无法识别，返回: ' + JSON.stringify(res.data).substring(0, 200)));
            }
          } else {
            console.error('响应数据为空:', res);
            reject(new Error('AI 返回空响应'));
          }
        } else {
          console.error('Coze API 错误，状态码:', res.statusCode);
          console.error('错误响应:', res.data);
          reject(new Error('API 调用失败: ' + res.statusCode + ' - ' + JSON.stringify(res.data)));
        }
      },
      fail: (err) => {
        console.error('❌ Coze API 请求失败');
        console.error('🔴 错误详情:', err);
        console.error('🔴 错误消息:', err.errMsg);
        console.error('🔴 错误堆栈:', err.stack);
        console.error('🔴 完整错误对象:', JSON.stringify(err));
        reject(new Error('网络请求失败: ' + (err.errMsg || JSON.stringify(err))));
      },
      complete: (res) => {
        console.log('🏁 请求完成:', res);
      }
    });
  });
}

/**
 * 分析梦境内容 - 包括情绪和分类
 * @param {string} dreamContent - 梦境内容
 * @param {boolean} isShort - 是否为短句分析
 * @returns {Promise} 返回分析结果
 */
async function analyzeDream(dreamContent, isShort = false) {
  try {
    console.log('开始分析梦境:', dreamContent);
    console.log('是否为短句分析:', isShort);
    
    // 根据是否为短句，使用不同的提示词
    const shortInstructions = isShort ? `
特别注意：这是一个非常简短的梦境描述，内容有限。请根据以下要求进行分析：
1. 情绪分析：即使是短句，也要尽可能提取核心情绪关键词，并根据语境推测情绪值
2. 关键词标签：从短句中提取1-2个最具代表性的关键词即可
3. 梦境类型：根据关键词进行合理推测
4. 解析内容：简洁明了地给出核心解析，无需详细展开

示例：如果梦境是"我飞起来了"，可以分析为：
- 情绪：快乐(高)、兴奋(高)、压力(低)、焦虑(低)
- 标签：飞翔、自由
- 类型：飞翔星球
- 解析：飞翔梦境通常代表对自由的渴望和内心的解脱
` : '';
    
    const prompt = `请分析以下梦境内容，并返回JSON格式的结果。${shortInstructions}

要求：
1. 分析情绪指数（0-100的数值）：压力、快乐、焦虑、兴奋
2. 提取关键词标签（1-5个，根据内容长度调整，短句至少1个）
3. 判断梦境类型（从以下类型中选择一个）：
   - 飞翔星球（包含飞翔、飞行、天空、自由等）
   - 海洋星球（包含海洋、水、游泳、潜水等）
   - 森林星球（包含森林、树木、自然、动物等）
   - 迷宫星球（包含迷宫、迷失、寻找、困惑等）
   - 城市星球（包含城市、建筑、街道、人群等）
   - 奇幻星球（包含魔法、超能力、怪物、奇幻生物等）
   - 恐怖星球（包含恐惧、追逐、黑暗、危险等）
   - 童年星球（包含童年回忆、学校、玩耍等）

4. 提供专业的梦境解析（根据内容长度调整详细程度，短句要简洁但有价值）

请严格按照以下JSON格式返回，不要添加任何其他文字：
{
  "emotions": [
    {"name": "压力", "value": 数值},
    {"name": "快乐", "value": 数值},
    {"name": "焦虑", "value": 数值},
    {"name": "兴奋", "value": 数值}
  ],
  "tags": ["标签1", "标签2", "标签3"],
  "planetType": "星球类型名称",
  "interpretation": "梦境解析内容"
}

梦境内容：${dreamContent}`;

    console.log('发送请求到 Coze API...');
    const response = await chatWithCoze(prompt);
    console.log('收到 Coze API 响应:', response);
    
    // 检查响应
    if (!response || !response.content) {
      console.error('Coze API 响应格式错误:', response);
      throw new Error('AI 返回内容为空');
    }
    
    // 解析 AI 返回的内容
    let content = response.content || '';
    console.log('原始返回内容:', content);
    
    // 尝试提取 JSON（AI 可能返回带 markdown 格式的 JSON）
    const jsonMatch = content.match(/\{[\s\S]*\}/);
    if (jsonMatch) {
      content = jsonMatch[0];
      console.log('提取的 JSON:', content);
    }
    
    const result = JSON.parse(content);
    console.log('解析后的结果:', result);
    
    // 验证数据格式
    if (!result.emotions || !result.tags || !result.planetType) {
      console.error('数据格式验证失败:', result);
      throw new Error('AI 返回数据格式不正确');
    }
    
    console.log('分析成功:', result);
    return result;
  } catch (error) {
    console.error('分析梦境失败:', error);
    console.error('错误详情:', {
      message: error.message,
      stack: error.stack,
      name: error.name
    });
    throw error;
  }
}

/**
 * 仅获取梦境分类（轻量级）
 * @param {string} dreamContent - 梦境内容
 * @returns {Promise} 返回分类结果
 */
async function classifyDream(dreamContent) {
  try {
    const prompt = `请将以下梦境分类到以下类型之一（只返回类型名称，不要其他内容）：
- 飞翔星球
- 海洋星球
- 森林星球
- 迷宫星球
- 城市星球
- 奇幻星球
- 恐怖星球
- 童年星球

梦境内容：${dreamContent}`;

    const response = await chatWithCoze(prompt);
    const planetType = response.content.trim();
    
    return { planetType };
  } catch (error) {
    console.error('分类梦境失败:', error);
    throw error;
  }
}

module.exports = {
  chatWithCoze,
  analyzeDream,
  classifyDream
};

